/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.moxiu.browser;

import android.content.Context;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.text.Editable;
import android.text.TextUtils;
import android.text.TextWatcher;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.util.Log;
import android.util.Patterns;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.view.inputmethod.EditorInfo;
import android.view.inputmethod.InputMethodManager;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.AutoCompleteTextView;
import android.widget.TextView;
import android.widget.TextView.OnEditorActionListener;

import com.moxiu.launcher.R;
import com.moxiu.launcher.config.BDStatistic;
import com.moxiu.launcher.config.StaticMethod;
import com.moxiu.browser.SuggestionsAdapter.CompletionListener;
import com.moxiu.browser.SuggestionsAdapter.SuggestItem;
import com.moxiu.browser.preferences.BrowserAlcPost;
import com.moxiu.browser.search.SearchEngine;
import com.moxiu.browser.search.SearchEngineInfo;
import com.moxiu.browser.search.SearchEngines;

import java.util.List;

/**
 * url/search input view
 * handling suggestions
 */
public class UrlInputView extends AutoCompleteTextView
        implements OnEditorActionListener,
        CompletionListener, OnItemClickListener, TextWatcher {
	static final String TAG="InputView";
    static final String TYPED = "browser-type";
    static final String SUGGESTED = "browser-suggest";

    static final int POST_DELAY = 100;

    static interface StateListener {
        static final int STATE_NORMAL = 0;
        static final int STATE_HIGHLIGHTED = 1;
        static final int STATE_EDITED = 2;

        public void onStateChanged(int state);
    }

    private UrlInputListener   mListener;
    private InputMethodManager mInputManager;
//    private SuggestionsAdapter mAdapter;
    public NavigationBarPhone mContainer;
    private boolean mLandscape;
    private boolean mIncognitoMode;
    private boolean mNeedsUpdate;

    public int mState;
    private StateListener mStateListener;
    private Drawable forward;
    private Drawable mRefreshDrawable;
    private boolean isclik=false;
    private Context mcontext;
    public boolean isgone=false; 
    private BrowserAlcPost browserAlcPost;
    String manufacturer = android.os.Build.MANUFACTURER;
    
    /**
     * 从首页搜索框引入
     */
    public boolean isFromSearch;

    public UrlInputView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init(context);
    }

    public UrlInputView(Context context, AttributeSet attrs) {
        this(context, attrs, android.R.attr.autoCompleteTextViewStyle);
    }

    public UrlInputView(Context context) {
        this(context, null);
    }

    private void init(Context ctx) {
    	mcontext=ctx;
    	Resources resources = mContext.getResources();
    	forward = resources.getDrawable(R.drawable.br_search_go);
    	mRefreshDrawable = resources.getDrawable(R.drawable.br_search_refresh);
    	
        mInputManager = (InputMethodManager) ctx.getSystemService(Context.INPUT_METHOD_SERVICE);
        setOnEditorActionListener(this);
//        mAdapter = new SuggestionsAdapter(ctx, this);
//        setAdapter(mAdapter);
       // setSelectAllOnFocus(true);
        onConfigurationChanged(ctx.getResources().getConfiguration());
        setThreshold(1);
        setOnItemClickListener(this);
        mNeedsUpdate = false;
        addTextChangedListener(this);
        setDropDownAnchor(View.NO_ID);//com.moxiu.browser.R.id.taburlbar);
        View v = getRootView().findViewById(com.moxiu.launcher.R.id.nav_top_bar);
        mState = StateListener.STATE_NORMAL;
        DisplayMetrics metrics = mContext.getResources().getDisplayMetrics();
        
        setDropDownWidth(metrics.widthPixels);
        browserAlcPost = new BrowserAlcPost(ctx);
    }

    protected void onFocusChanged(boolean focused, int direction, Rect prevRect) {
        super.onFocusChanged(focused, direction, prevRect);
          
        InputMethodManager imm = (InputMethodManager) mcontext.getSystemService(Context.INPUT_METHOD_SERVICE);
        
        int state = -1;
        //Log.e("wang", "得到的焦点状态==="+focused);
        if (focused) {
//        	屏蔽之前地址栏点击
//        	browserAlcPost.setBrowserData(browserAlcPost.ACT_TYPE, browserAlcPost.B_CLICK);
//        	browserAlcPost.setBrowserData(browserAlcPost.BUSINESS_RESOURCE, browserAlcPost.SEARCH_ADDRESS);
//        	browserAlcPost.postAlcData(mContext);
        	this.setCursorVisible(true);
            if (hasSelection()) {
                state = StateListener.STATE_HIGHLIGHTED;
            } else {
                state = StateListener.STATE_EDITED;
            }
            isgone=true;
            if (getText().length() > 0) {
            	mContainer.getStop().setVisibility(View.VISIBLE);
            } else {
            	mContainer.getStop().setVisibility(View.GONE);
            }
        } else {
            try {
				// reset the selection state
				this.setCursorVisible(false);
				UiController controller=mContainer.getController();
				if(controller!=null){        	
					 String txt = controller.getCurrentTab().getTitle();
					 if (TextUtils.isEmpty(txt) || BrowserSettings.getFactoryResetHomeUrl(mcontext).equals(controller.getCurrentTab().getUrl())) {
					     txt = controller.getCurrentTab().getUrl();
					 }
				    if(!TextUtils.isEmpty(txt)){
				    	this.setText(txt);
				    }
				    
				 	isgone=false;
					mContainer.getStop().setVisibility(View.GONE);
//        	mContainer.getTipTv().setBackgroundDrawable(mRefreshDrawable);
//        	mContainer.getTipTv().setText("刷新");
				}

      
				state = StateListener.STATE_NORMAL;
			} catch (IndexOutOfBoundsException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
        }
        final int s = state;
        post(new Runnable() {
            public void run() {
                changeState(s);
            }
        });
       
    }

    @Override
    public boolean onTouchEvent(MotionEvent evt) {
    	
    	if (UrlInputView.this ==null  || evt == null  ) {
			return true;
		}
        boolean hasSelection = hasSelection();
        boolean res = super.onTouchEvent(evt);
        if ((MotionEvent.ACTION_DOWN == evt.getActionMasked())&&hasSelection) {
            postDelayed(new Runnable() {
                public void run() {
                    changeState(StateListener.STATE_EDITED);
                }}, POST_DELAY);
        }
        return res;
    }

    /**
     * check if focus change requires a title bar update
     */
    boolean needsUpdate() {
        return mNeedsUpdate;
    }

    /**
     * clear the focus change needs title bar update flag
     */
    void clearNeedsUpdate() {
        mNeedsUpdate = false;
    }

    void setController(UiController controller,BaseUi baseUi,int mTitleBarHeight) {
        UrlSelectionActionMode urlSelectionMode
                = new UrlSelectionActionMode(controller,baseUi,mTitleBarHeight);
        setCustomSelectionActionModeCallback(urlSelectionMode);
    }

    void setContainer(View container) {
        mContainer = (NavigationBarPhone) container;
    }

    public void setUrlInputListener(UrlInputListener listener) {
        mListener = listener;
    }

    public void setStateListener(StateListener listener) {
        mStateListener = listener;
        // update listener
        changeState(mState);
    }

    private void changeState(int newState) {
        mState = newState;
        if (mStateListener != null) {
            mStateListener.onStateChanged(mState);
        }
    }
    

    int getState() {
        return mState;
    }

    @Override
    protected void onConfigurationChanged(Configuration config) {
        super.onConfigurationChanged(config);
        mLandscape = (config.orientation &
                Configuration.ORIENTATION_LANDSCAPE) != 0;
//        mAdapter.setLandscapeMode(mLandscape);
        if (isPopupShowing() && (getVisibility() == View.VISIBLE)) {
            dismissDropDown();
            showDropDown();
            performFiltering(getText(), 0);
        }
    }

    @Override
    public void dismissDropDown() {
        super.dismissDropDown();
//        mAdapter.clearCache();
    }

    @Override
    public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
    	BDStatistic.postBrowserSearchBtn(getContext());
        finishInput(getText().toString(), null, TYPED);

        return true;
    }

    void forceFilter() {
        showDropDown();
    }

    public boolean isIMEOpen() {
    	return mInputManager.isActive();
    }
    void hideIME() {
        mInputManager.hideSoftInputFromWindow(getWindowToken(), 0);
    }

    void showIME() {
    	mInputManager.focusIn(this);
        if (!"Meizu".equalsIgnoreCase(manufacturer)) {
        	mInputManager.showSoftInput(this, 0);
    	}
    }

    public void finishInput(String url, String extra, String source) {
        mNeedsUpdate = true;
        dismissDropDown();
        hideIME();
        if (url == null || TextUtils.isEmpty(url.trim())) {
        	url="www.baidu.com";
        }
        if (TextUtils.isEmpty(url)) {
            mListener.onDismiss();
            mListener.onAction(url, extra, source);
        } else {
            if (mIncognitoMode && isSearch(url)) {//是搜索则处理链接
                // To prevent logging, intercept this request
                // TODO: This is a quick hack, refactor this
                SearchEngine searchEngine = BrowserSettings.getInstance()
                        .getSearchEngine();
                if (searchEngine == null) return;
                SearchEngineInfo engineInfo = SearchEngines
                        .getSearchEngineInfo(mContext, searchEngine.getName());
                if (engineInfo == null) return;
                url = engineInfo.getSearchUriForQuery(url);
                // mLister.onAction can take it from here without logging
            }
            if(!isSearch(url)){  
         	   if(!TextUtils.isEmpty(UrlUtils.fixUrl(url).trim())){
         			mListener.onStor_his(url);         	
             	}
             }
            mListener.onAction(url, extra, source);
        }
    }

    boolean isSearch(String inUrl) {
        String url = UrlUtils.fixUrl(inUrl).trim();
        if (TextUtils.isEmpty(url)) return false;

        if (Patterns.WEB_URL.matcher(url).matches()
                || UrlUtils.ACCEPTED_URI_SCHEMA.matcher(url).matches()) {
            return false;
        }
        return true;
    }

    // Completion Listener

    @Override
    public void onSearch(String search) {
        mListener.onCopySuggestion(search);
    }

    @Override
    public void onSelect(String url, int type, String extra) {
//    	屏蔽之前的搜索上报
//    	browserAlcPost.setBrowserData(browserAlcPost.BUSINESS_RESOURCE, browserAlcPost.SEARCH_ADDRESS);
//    	browserAlcPost.setBrowserData(browserAlcPost.ACT_TYPE, browserAlcPost.B_SEARCH);
//    	browserAlcPost.setBrowserData(BrowserAlcPost.SEARCH_WD, url);
//    	browserAlcPost.setBrowserData(browserAlcPost.SEARCH_DISTRIBUTE, browserAlcPost.getSearchEngine(BrowserSettings.getInstance().getSearchEngine().getName()));
//    	browserAlcPost.postAlcData(mcontext);
//    	browserAlcPost.setBrowserData(BrowserAlcPost.SEARCH_WD, url);
        finishInput(url, extra, SUGGESTED);
    }

    @Override
    public void onItemClick(
            AdapterView<?> parent, View view, int position, long id) {
//        SuggestItem item = mAdapter.getItem(position);
//        onSelect(SuggestionsAdapter.getSuggestionUrl(item), item.type, item.extra);
    }

    interface UrlInputListener {

        public void onDismiss();

        public void onAction(String text, String extra, String source);

        public void onCopySuggestion(String text);
        
        public void onStor_his(String word);

    }

    public void setIncognitoMode(boolean incognito) {
        mIncognitoMode = incognito;
//        mAdapter.setIncognitoMode(mIncognitoMode);
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent evt) {
        if (keyCode == KeyEvent.KEYCODE_ESCAPE && !isInTouchMode()) {
        	browserAlcPost.setBrowserData(browserAlcPost.SEARCH_DISTRIBUTE, browserAlcPost.getSearchEngine(BrowserSettings.getInstance().getSearchEngine().getName()));
            finishInput(null, null, null);
            return true;
        }
        
        return super.onKeyDown(keyCode, evt);
    }

//    public SuggestionsAdapter getAdapter() {
//        return mAdapter;
//    }

    /*
     * no-op to prevent scrolling of webview when embedded titlebar
     * gets edited
     */
    @Override
    public boolean requestRectangleOnScreen(Rect rect, boolean immediate) {
        return false;
    }

    @Override
    public void beforeTextChanged(CharSequence s, int start, int count, int after) { }

    @Override
    public void onTextChanged(CharSequence s, int start, int before, int count) {
    	if ((StateListener.STATE_NORMAL == mState || StateListener.STATE_EDITED == mState) && (BrowserSettings.getFactoryResetHomeUrl(mcontext).equals(s.toString())
    												|| BrowserSettings.getHomePageTitle().trim().equals(s.toString().trim()))) {
        	setText("");
        	return;
        }
        if (StateListener.STATE_HIGHLIGHTED == mState) {    
        	
            changeState(StateListener.STATE_EDITED);
           
        }
        

        
    }
    
    
    
    

    @Override
    public void afterTextChanged(Editable s) { }

    
    private boolean isWebAddress(CharSequence s) {
    	if (TextUtils.isEmpty(s)) {
    		return false;
    	}
    	String input = s.toString();
    	if (input.length() < 3 || !input.contains(".") || input.startsWith(".")) {
    		return false;
    	}
    	
    	String dotBack = input.substring(input.indexOf('.'));
    	
    	
    	if (TextUtils.isEmpty(dotBack)) {
    		return false;
    	}
    	
    	if (dotBack.length() < 3) {
    		return false;
    	}
    	if (!dotBack.substring(1, 2).equals(".") && !dotBack.substring(2, 3).equals(".")) {
    		return true;
    	}
    	
    	return false;
    }
}
